home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 11 / CU Amiga Magazine's Super CD-ROM 11 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-06].iso / cucd / programming / oberonv4 / text / exprmaple.text (.txt) < prev    next >
Oberon Text  |  1996-02-28  |  10KB  |  178 lines
  1. Syntax20m.Scn.Fnt
  2. ParcElems
  3. Alloc
  4. Syntax12i.Scn.Fnt
  5. Syntax14m.Scn.Fnt
  6. StyleElems
  7. Alloc
  8. Title
  9. Syntax12.Scn.Fnt
  10. Title
  11. Example
  12. FoldElems
  13. Syntax12.Scn.Fnt
  14. StyleElems
  15. Alloc
  16. Syntax10.Scn.Fnt
  17. Example
  18. interface(prettyprint = 0);
  19. interface(echo = 0);
  20. interface(warnlevel = 0);
  21. alias(const(infinity) = infinity):
  22. alias(const(e) = exp(1)):
  23. alias(const(pi) = Pi):
  24. alias(`factorial `= factorial):
  25. alias(gamma = GAMMA):
  26. alias(ceiling = ceil):
  27. alias(I = I):
  28. systemlimit := eval(limit):
  29. protect(systemlimit):
  30. unprotect(limit):
  31. limit := proc(f, x, x0, dir)
  32.     local s;
  33.     if type(x, 'equation') then systemlimit(args)
  34.     else
  35.         if dir = 1 then s := systemlimit(f, x = x0, right)
  36.         elif dir = -1 then s := systemlimit(f, x = x0, left)
  37.         else s := systemlimit(f, x = x0)
  38.         fi;
  39.         if type(s, 'range') then 'procname(args)' else s fi
  40. protect(limit):
  41. `print/limit` := proc(f, eq, dir)
  42.     local d;
  43.     if nargs = 4 then 'limit(args)'
  44.     else
  45.         if nargs = 3 then
  46.             if dir = 'left' then d := -1 else d := 1 fi
  47.         else d := 0
  48.         fi;
  49.         'limit'(f, lhs(eq), rhs(eq), d)
  50. systemint := eval(int):
  51. protect(systemint):
  52. unprotect(int):
  53. int := proc(f, x, a, b)
  54.     if nargs = 2 then systemint(args)
  55.     else systemint(f, x = a .. b)
  56. protect(int):
  57. `print/int` := proc(f, eq)
  58.     if type(eq, 'equation') then
  59.         'int'(f, lhs(eq), op(rhs(eq)))
  60.     else 'int(args)'
  61. `print/exp` := x -> exp(1)^(x):
  62. read `/dev/tty`:
  63. Syntax12.Scn.Fnt
  64. StyleElems
  65. Alloc
  66. Syntax10.Scn.Fnt
  67. Example
  68. # csh
  69. stty -echo -ocrnl -imaxbel -icanon min 1 time 0
  70. maple -q < .qmapleinit
  71. stty sane
  72. Title
  73. ExprIcons
  74. Alloc
  75. ExprViews
  76. AllocPlaceholder
  77. ExprStd
  78. AllocInteger
  79. ExprStd
  80. AllocSymbol
  81. ExprStd
  82. AllocBinaryOp
  83. ExprStd
  84. AllocPower
  85. ExprIcons
  86. AllocGraph
  87. Example
  88. ExprSlang
  89. Alloc
  90. ExprSlang
  91. Alloc
  92. Example
  93. ExprMaple
  94. AllocScript
  95. Factor
  96. Syntax10.Scn.Fnt
  97. ExprIcons
  98. Alloc
  99. ExprViews
  100. AllocPlaceholder
  101. ExprIcons
  102. AllocGraph
  103. factor(
  104. Example
  105. ExprSlang
  106. Alloc
  107. Factor
  108. Syntax10.Scn.Fnt
  109. ExprIcons
  110. Alloc
  111. ExprViews
  112. AllocPlaceholder
  113. ExprIcons
  114. AllocGraph
  115. factor(
  116. Example
  117. ExprSlang
  118. Alloc
  119. Example
  120. Anihilate
  121. Syntax12i.Scn.Fnt
  122. ExprIcons
  123. Alloc
  124. ExprViews
  125. AllocPlaceholder
  126. ExprIcons
  127. AllocGraph
  128. Example
  129. ExprSlang
  130. Alloc
  131. Example
  132. Anihilate
  133. Syntax12i.Scn.Fnt
  134. ExprIcons
  135. Alloc
  136. ExprViews
  137. AllocPlaceholder
  138. ExprIcons
  139. AllocGraph
  140. Example
  141. ExprSlang
  142. Alloc
  143. Title
  144. Syntax14b.Scn.Fnt
  145. ExprMaple - User's Guide
  146. Wolfgang Weck
  147. Institute for Scientific Computing
  148. ETH Z
  149. Weck@inf.ethz.ch
  150. Introduction
  151. The ExprMaple package allows the ExpressionIcon editing package to interact with the Maple system. This interaction is limited in several aspects: Only singular operations on expressions are supported - in contrast to programming and the like. The interface does neither prohibit nor support other uses of Maple and has to be considered experimental with respect to this. Further, there is extra preparation needed for Maple to understand new extensions of the core package. In this version the expressions from the core package including the Lib0 extensions - but not the matrix extension - are supported. To increase portability of the entire system it is assumed that the user connects the system to Maple manually. It is described bellow how to do that. However, the Maple interface offers a programming interface too, thus allowing for programming script like modules.
  152. Setting up the Maple Interface
  153. The interface interacts with Maple through a serial communication link as provided by module Sessions. To install the interface in a specific session, execute the command ExprMaple.Install after marking a viewer that holds a terminal to that session. Maple is assumed to be running already in that session. Further, the echo of tty is supposed to be turned of and a special initialization file is expected to be executed by Maple, which needs to run in quiet mode. The typical sequence of actions on a Sparc computer is the following:
  154. Terminal.Open ~
  155.     given that .qmapleinit contains:    
  156. .qmapleinit
  157.     execute within that terminal the script qmaple:    
  158. qmaple script
  159.     mark the viewer containing the terminal
  160. ExprMaple.Install
  161. After this the terminal might be closed or as well kept open for a session protocol and to close the connection after the session. To remove the link from the interface to the current session execute ExprMaple.Remove .
  162. Evaluating with Maple
  163. Two possibilities exist to activate an evaluation by Maple: One can simply apply the command ExprMaple.Eval 
  164.   to the least recent selected expression or activate a script. The former sends the selected expression to Maple and replaces it by the answer provided by Maple. This allows for simple simplifications of expressions:
  165. ExprMaple.Eval 
  166. To execute more sophisticated transformations with Maple, scripts need to be employed. These are text elements. The command ExprMaple.InsertScript inserts a new and empty script at the current focus position (caret). To edit a script, it must be opened through a middle-left interclick on it. Opening will display a new text viewer allowing to edit the script's contents. Also, editing the viewers name will cause the script's name to change. To make changes permanent, execute Icons.Update in the menu area of the viewer.
  167. A script can be activated simply by clicking the middle mouse button on it. Upon activation the contents of the script will be sent to Maple literally. The only change happening is that every occurrence of an Placeholder-expression is substituted by the least recent selected expression.
  168. Assume a script 
  169.  containing the text factor(
  170. The script 
  171.  holds the text 
  172.  and should almost ever result in 0:
  173. Whenever a Maple interface command is activated, the least recent selected expression is going to be replaced by the result of the Maple operation. If this selection is a text stretch it is immediately replaced by an icon. Thus, in any case, there exists a single icon in a document that is going to be changed through the Maple operation. This icon is being marked by horizontal lines as currently not valid. (If a subexpression within an icon has been selected, only this subexpression is going to be changed but the entire icon is marked.) However, this mark does not prevent the user from deleting or copying it. But note, that only the original instance of the icon is going to be affected by the Maple operation. If the user deletes that instance, the result will be lost.
  174. In case that the Maple operation produced an undesired result, the command ExprMaple.Undo can be used to undo a single. Again, this operation works on the icon used for display of the result only.
  175. Example: Interactive Paper on Formula Manipulation using Maple
  176. For further examples of useful scripts see the text ExprMaple.Tool text.
  177. As a more sophisticated example, MapleFormManip.Text containes a reformulated and slightly changed version of a paper entitled Formula Manipulation using Maple by Dominik Gruntz from The Maple Technical Newsletter, Issue 10. It has been compiled in a primitive example of an interactive paper - a small version of an interactive text book.
  178.